package com.smart.community.property.controller;

import java.util.ArrayList;
import java.util.List;

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.smart.community.property.service.IPropertyCompanyCommunityService;
import com.smart.community.commons.entity.property.PropertyCompanyCommunity;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

/**
 * 物业公司社区关联Feign接口实现Controller
 * 
 * @author Wu.Liang
 * @version 1.0.0
 * @since 2025-06-29
 */
@Slf4j
@RestController
@RequestMapping("/property")
@Tag(name = "物业公司社区关联Feign接口", description = "物业公司社区关联相关Feign接口")
@RequiredArgsConstructor
@Validated
public class PropertyCompanyCommunityFeignController {

    private final IPropertyCompanyCommunityService propertyCompanyCommunityService;
    


    /**
     * 分配社区给物业公司（Feign接口实现）
     * 
     * @param propertyCompanyId 物业公司ID
     * @param communityIds 社区ID列表
     */
    @PostMapping("/feign/company-communities/assign/{propertyCompanyId}")
    @Operation(summary = "分配社区给物业公司")
    public void assignCommunities(
            @Parameter(description = "物业公司ID") @PathVariable("propertyCompanyId") Long propertyCompanyId,
            @Parameter(description = "社区ID列表") @RequestBody List<Long> communityIds) throws Exception {
        log.info("Feign接口：分配社区给物业公司，物业公司ID：{}，社区ID列表：{}", propertyCompanyId, communityIds);
        
        // Feign接口调用：直接执行分配操作，跳过权限检查
        // 因为Feign接口通常用于服务间调用，权限已在调用方验证
        propertyCompanyCommunityService.assignCommunitiesToPropertyCompanyWithoutPermission(propertyCompanyId, communityIds);
        log.info("Feign接口：分配社区给物业公司成功，物业公司ID：{}", propertyCompanyId);
    }

    /**
     * 根据物业公司ID查询关联的社区ID列表（Feign接口实现）
     * 
     * @param propertyCompanyId 物业公司ID
     * @return 社区ID列表
     */
    @GetMapping("/feign/company-communities/property-company/{propertyCompanyId}")
    @Operation(summary = "根据物业公司ID查询关联的社区ID列表")
    public List<Long> getCommunityIdsByPropertyCompanyId(
            @Parameter(description = "物业公司ID") @PathVariable("propertyCompanyId") Long propertyCompanyId) throws Exception {
        log.info("Feign接口：根据物业公司ID查询关联的社区ID列表，物业公司ID：{}", propertyCompanyId);
        List<com.smart.community.commons.entity.property.PropertyCompanyCommunity> communities = 
                propertyCompanyCommunityService.getPropertyCompanyCommunities(propertyCompanyId);
        
        List<Long> communityIds = communities.stream()
                .map(com.smart.community.commons.entity.property.PropertyCompanyCommunity::getCommunityId)
                .collect(java.util.stream.Collectors.toList());
        
        log.info("Feign接口：根据物业公司ID查询关联的社区ID列表成功，物业公司ID：{}，社区ID数量：{}", propertyCompanyId, communityIds.size());
        return communityIds;
    }

    /**
     * 检查物业公司是否关联指定社区（Feign接口实现）
     * 
     * @param propertyCompanyId 物业公司ID
     * @param communityId 社区ID
     * @return 是否关联
     */
    @GetMapping("/feign/company-communities/check/{propertyCompanyId}/{communityId}")
    @Operation(summary = "检查物业公司是否关联指定社区")
    public Boolean checkPropertyCompanyHasCommunity(
            @Parameter(description = "物业公司ID") @PathVariable("propertyCompanyId") Long propertyCompanyId,
            @Parameter(description = "社区ID") @PathVariable("communityId") Long communityId) throws Exception {
        log.info("Feign接口：检查物业公司是否关联指定社区，物业公司ID：{}，社区ID：{}", propertyCompanyId, communityId);
        Boolean result = propertyCompanyCommunityService.isPropertyCompanyAssignedToCommunity(propertyCompanyId, communityId);
        log.info("Feign接口：检查物业公司是否关联指定社区成功，物业公司ID：{}，社区ID：{}，结果：{}", propertyCompanyId, communityId, result);
        return result;
    }

    /**
     * 根据社区ID获取物业公司ID（Feign接口实现）
     * 
     * @param communityId 社区ID
     * @return 物业公司ID，如果没有关联则返回null
     */
    @GetMapping("/feign/company-communities/property-company-by-community/{communityId}")
    @Operation(summary = "根据社区ID获取物业公司ID")
    public Long getPropertyCompanyIdByCommunityId(
            @Parameter(description = "社区ID") @PathVariable("communityId") Long communityId) throws Exception {
        log.info("Feign接口：根据社区ID获取物业公司ID，社区ID：{}", communityId);
        try {
            PropertyCompanyCommunity relation = propertyCompanyCommunityService.getCurrentPropertyCompanyForCommunity(communityId);
            if (relation != null) {
                Long propertyCompanyId = relation.getPropertyCompanyId();
                log.info("Feign接口：根据社区ID获取物业公司ID成功，社区ID：{}，物业公司ID：{}", communityId, propertyCompanyId);
                return propertyCompanyId;
            } else {
                log.info("Feign接口：社区ID：{} 未关联任何物业公司", communityId);
                return null;
            }
        } catch (Exception e) {
            log.error("Feign接口：根据社区ID获取物业公司ID失败，社区ID：{}", communityId, e);
            return null;
        }
    }

    /**
     * 移除物业公司与社区的关联（Feign接口实现）
     * 
     * @param id 关联ID
     * @return 操作结果
     */
    @DeleteMapping("/feign/company-communities/{id}")
    @Operation(summary = "移除物业公司与社区的关联")
    public void removeCommunityRelation(@Parameter(description = "关联ID") @PathVariable("id") Long id) throws Exception {
        log.info("Feign接口：移除物业公司与社区的关联，关联ID：{}", id);
        propertyCompanyCommunityService.removePropertyCompanyCommunity(id);
        log.info("Feign接口：移除物业公司与社区的关联成功，关联ID：{}", id);
    }

    /**
     * 批量移除物业公司与社区的关联（Feign接口实现）
     * 
     * @param propertyCompanyId 物业公司ID
     */
    @DeleteMapping("/batch/{propertyCompanyId}")
    @Operation(summary = "批量移除物业公司与社区的关联")
    public void removeCommunityRelations(
            @Parameter(description = "物业公司ID") @PathVariable("propertyCompanyId") Long propertyCompanyId) throws Exception {
        log.info("Feign接口：批量移除物业公司与社区的关联，物业公司ID：{}", propertyCompanyId);
        List<com.smart.community.commons.entity.property.PropertyCompanyCommunity> communities = 
                propertyCompanyCommunityService.getPropertyCompanyCommunities(propertyCompanyId);
        
        List<Long> communityIds = communities.stream()
                .map(com.smart.community.commons.entity.property.PropertyCompanyCommunity::getCommunityId)
                .collect(java.util.stream.Collectors.toList());
        
        if (!communityIds.isEmpty()) {
            propertyCompanyCommunityService.batchRemovePropertyCompanyCommunities(propertyCompanyId, communityIds);
            log.info("Feign接口：批量移除物业公司与社区的关联成功，物业公司ID：{}，移除数量：{}", propertyCompanyId, communityIds.size());
        }
    }

    /**
     * 批量根据物业公司ID列表获取社区ID列表（Feign接口实现）
     * 
     * @param propertyCompanyIds 物业公司ID列表
     * @return 社区ID列表
     */
    @PostMapping("/communities-by-property-companies")
    @Operation(summary = "批量根据物业公司ID列表获取社区ID列表")
    public List<Long> getCommunityIdsByPropertyCompanyIds(@Parameter(description = "物业公司ID列表") @RequestBody List<Long> propertyCompanyIds) throws Exception {
        log.info("Feign接口：批量根据物业公司ID列表获取社区ID列表，物业公司ID数量：{}", propertyCompanyIds != null ? propertyCompanyIds.size() : 0);
        
        if (propertyCompanyIds == null || propertyCompanyIds.isEmpty()) {
            log.warn("Feign接口：物业公司ID列表为空，返回空列表");
            return new ArrayList<>();
        }
        
        try {
            List<Long> allCommunityIds = new ArrayList<>();
            for (Long propertyCompanyId : propertyCompanyIds) {
                List<Long> communityIds = propertyCompanyCommunityService.getCommunityIdsByPropertyCompanyId(propertyCompanyId);
                if (communityIds != null && !communityIds.isEmpty()) {
                    allCommunityIds.addAll(communityIds);
                }
            }
            
            // 去重
            List<Long> distinctCommunityIds = allCommunityIds.stream()
                    .distinct()
                    .collect(java.util.stream.Collectors.toList());
            
            log.info("Feign接口：批量根据物业公司ID列表获取社区ID列表成功，物业公司数量：{}，社区数量：{}", 
                    propertyCompanyIds.size(), distinctCommunityIds.size());
            return distinctCommunityIds;
        } catch (Exception e) {
            log.error("Feign接口：批量根据物业公司ID列表获取社区ID列表失败，物业公司ID列表：{}", propertyCompanyIds, e);
            return new ArrayList<>();
        }
    }
} 